Improving the Performance of User-level Runtime Systems for Concurrent Applications

Concurrency is an essential part of many modern large-scale software systems. Applications must handle millions of simultaneous requests from millions of connected devices. Handling such a large number of concurrent requests requires runtime systems that efficiently man- age concurrency and communication among tasks in an application across multiple cores. Existing low-level programming techniques provide scalable solutions with low overhead, but require non-linear control flow. Alternative approaches to concurrent programming, such as Erlang and Go, support linear control flow by mapping multiple user-level execution entities across multiple kernel threads (M:N threading). However, these systems provide comprehensive execution environments that make it difficult to assess the performance impact of user-level runtimes in isolation. This thesis presents a nimble M:N user-level threading runtime that closes this con- ceptual gap and provides a software infrastructure to precisely study the performance impact of user-level threading. Multiple design alternatives are presented and evaluated for scheduling, I/O multiplexing, and synchronization components of the runtime. The performance of the runtime is evaluated in comparison to event-driven software, system- level threading, and other user-level threading runtimes. An experimental evaluation is conducted using benchmark programs, as well as the popular Memcached application. The user-level runtime supports high levels of concurrency without sacrificing application performance. In addition, the user-level scheduling problem is studied in the context of an existing actor runtime that maps multiple actors to multiple kernel-level threads. In particular, two locality-aware work-stealing schedulers are proposed and evaluated. It is shown that locality-aware scheduling can significantly improve the performance of a class of applications with a high level of concurrency. In general, the performance and resource utilization of large-scale concurrent applications depends on the level of concurrency that can be expressed by the programming model. This fundamental effect is studied by refining and customizing existing concurrency models

Connecting vehicular networks to the internet : a life time-based routing protocol

Inter-Vehicle Communications have recently attracted the attention of researchers in academia and industry. In such networks, vehicles should be able to communicate among each other (V2V) as well as with roadside Infrastructure units (V2I). Vehicular networks try to provide safety on the roads by disseminating critical messages among vehicles. Infrastructure units provide some services such as driver information systems and Internet access. Because of the high speed and high mobility of vehicles, establishing and maintaining a connection to these units is very challenging. We introduce a new protocol that uses the characteristics of vehicle movements to predict the vehicle behavior and select a route with the longest life-time to connect to the wired network. It aims at spreading the advertisement messages through multi-hops without flooding the network, do seamless hand-overs and select the most stable routes to these units. We performed some simulations and compared the performance of our work with some well-known protocols